# 主界面类
import tkinter as tk
import os
import sys
from tkinter import ttk, filedialog,messagebox
import tkinter.font as tkfont  # 导入字体模块
from tkcalendar import DateEntry
import math
from docx import Document
from LLMProcess import LLMProcess
from WordChecker import WordChecker
from ConfigManager import ConfigManager
import Logger_config
from WordOptimizer import WordOptimizer

# 设置日志配置
logger = Logger_config.setup_logger()

class WordAIAssistant:
    def __init__(self, root):
        self.root = root
        self.root.title("AI文档智能助手")

        # 设置样式
        self.style = ttk.Style()        

        #加载配置
        self.load_config()     

        # 设置UI样式
        self.setup_styles()
        
        # 创建选项卡
        self.create_tabs()
        
        # 初始化变量
        self.init_variables()
        
        # 初始化菜单栏
        self.init_menu_bar()
    def init_menu_bar(self):
        # 创建自定义菜单栏容器
        menu_container = ttk.Frame(self.root)
        
        # 使用 place 方法将 menu_container 放置在右上角
        menu_container.place(relx=1.0, rely=0.0, anchor='ne')
        
        # 创建配置按钮的自定义样式
        self.style.configure("ConfigButton.TMenubutton", 
                            font=("Microsoft YaHei", 10))
        
        # 添加右侧配置按钮
        config_button = ttk.Menubutton(menu_container, 
                                    text="配置",
                                    style="ConfigButton.TMenubutton")
        config_button.pack(side=tk.RIGHT, padx=(0,20))
        
        # 创建下拉菜单
        config_menu = tk.Menu(config_button, tearoff=0, font=("Microsoft YaHei", 10))
        config_menu.add_command(label="大模型配置", command=self.show_model_config_panel)
        config_menu.add_command(label="恢复默认配置", command=self.confirm_restore)
        
        # 关联菜单
        config_button.config(menu=config_menu)

    def show_model_config_panel(self):
        config_window = self.create_toplevel_window("大模型配置", 480, 260)

        # 设置窗口置顶属性
        config_window.attributes('-topmost', True)

        # 获取当前配置
        config = self.cm.get_merged_config()['model']

        # 创建输入框和标签
        tk.Label(config_window, text="Base URL:").grid(row=0, column=0, padx=10, pady=10, sticky='e')
        self.base_url_entry = tk.Entry(config_window, width=50)
        self.base_url_entry.grid(row=0, column=1, padx=10, pady=10)
        self.base_url_entry.insert(0, config['base_url'])

        tk.Label(config_window, text="API Key:").grid(row=1, column=0, padx=10, pady=10, sticky='e')
        self.api_key_entry = tk.Entry(config_window, width=50)  # 隐藏输入内容
        self.api_key_entry.grid(row=1, column=1, padx=10, pady=10)
        self.api_key_entry.insert(0, config['api_key'])

        tk.Label(config_window, text="模型名称:").grid(row=2, column=0, padx=10, pady=10, sticky='e')
        self.model_name_entry = tk.Entry(config_window, width=50)
        self.model_name_entry.grid(row=2, column=1, padx=10, pady=10)
        self.model_name_entry.insert(0, config['model_name'])

        # 流式输出开关（使用 IntVar 存储状态，0 表示关闭，1 表示开启）
        tk.Label(config_window, text="流式输出:").grid(row=3, column=0, padx=10, pady=10, sticky='e')
        self.streaming_var = tk.IntVar(value=1 if config['stream'] else 0)
        self.streaming_checkbox = tk.Checkbutton(config_window, variable=self.streaming_var)
        self.streaming_checkbox.grid(row=3, column=1, padx=10, pady=10, sticky='w')

        # 按钮区域
        button_frame = tk.Frame(config_window)
        button_frame.grid(row=4, column=0, columnspan=2, pady=20)

        save_button = tk.Button(button_frame, text="保存", command=self.save_model_config, width=10, height=1)
        save_button.pack(side=tk.LEFT, padx=10)

        test_button = tk.Button(button_frame, text="连通性测试", command=self.test_model_connection, width=10, height=1)
        test_button.pack(side=tk.LEFT, padx=10)

        close_button = tk.Button(button_frame, text="关闭", command=config_window.destroy, width=10, height=1)
        close_button.pack(side=tk.LEFT, padx=10)
    def load_config(self):
        try:
            self.cm = ConfigManager()
            self.cm.check_config_version()
        except RuntimeError as e:
            messagebox.showerror("配置错误", f"加载配置失败，请找管理员解决: {e}")
            sys.exit(1)
    def confirm_restore(self):
        # 确认恢复默认设置的方法
        if messagebox.askyesno("确认", "确定要恢复默认配置吗？当前配置将被覆盖"):
            # 如果用户点击“是”，则调用ConfigManager的restore_default_config方法恢复默认配置
            self.cm.restore_default_config()
            # 重新获取最新的合并配置
            self.load_config()
            # 显示信息提示框，告知用户已恢复默认配置
            messagebox.showinfo("完成", "已恢复默认配置")
    def create_toplevel_window(self, title, width=None, height=None):
        """
        创建一个带有图标的通用 Toplevel 窗口，并可选地设置大小和居中显示

        :param title: 窗口标题
        :param width: 窗口宽度
        :param height: 窗口高度
        :return: 创建的 Toplevel 对象
        """
        window = tk.Toplevel(self.root)
        window.title(title)

        # 设置窗口图标
        if getattr(sys, 'frozen', False):  # 判断是否被打包
            base_path = sys._MEIPASS
        else:
            base_path = os.path.join(os.path.dirname(__file__), '..')

        icon_path = os.path.join(base_path, 'resources', 'OfficeAI.ico')
        if os.path.exists(icon_path):
            window.iconbitmap(icon_path)

        # 如果提供了宽高，则设置窗口尺寸并居中
        if width and height:
            screen_width = window.winfo_screenwidth()
            screen_height = window.winfo_screenheight()
            x_position = (screen_width - width) // 2
            y_position = (screen_height - height) // 2
            window.geometry(f"{width}x{height}+{x_position}+{y_position}")

        return window
    
    def save_model_config(self):
        """
        保存大模型配置。
        """
        base_url = self.base_url_entry.get().strip()
        api_key = self.api_key_entry.get().strip()
        model_name = self.model_name_entry.get().strip()
        streaming = bool(self.streaming_var.get())

        config = self.cm.get_merged_config()

        # 更新配置文件中的model字段
        config['model']['base_url'] = base_url
        config['model']['api_key'] = api_key
        config['model']['model_name'] = model_name
        config['model']['stream'] = streaming

        self.cm.save_user_config(config)

        # 重新获取最新的合并配置
        self.load_config()

        # 关闭配置面板
        self.base_url_entry.master.destroy()

    def test_model_connection(self):
        """
        测试大模型的连接性。
        """
        base_url = self.base_url_entry.get().strip()
        api_key = self.api_key_entry.get().strip()
        model_name = self.model_name_entry.get().strip()
        streaming = bool(self.streaming_var.get())

        try:
            result = LLMProcess.getLLMTextResponse(model_name, api_key, base_url, 4096, 0.7, streaming, [{"role": "user", "content": "你好"}])        

            if result:
                messagebox.showinfo("测试结果", "连接成功！")
            else:
                messagebox.showerror("连接失败，请检查配置参数是否正确，或检查网络连通性，或检查账户是否有余额。")

        except Exception as e:
            messagebox.showerror("错误", f"连接测试失败: {str(e)}")
        
    def setup_styles(self):
        """设置界面样式"""
        
        self.style.theme_use('xpnative')  #应用主题
        # self.style.theme_use('clam')  #应用主题
        print("可用主题:", self.style.theme_names())        
        
        # 配置Tab样式    
        self.style.configure(".TNotebook.Tab",  # 修改样式名称
                            padding=(15, 2),
                            font=("Microsoft YaHei", 12, "bold"))
        self.style.map(".TNotebook.Tab",
                    relief=[("pressed", "sunken")])
        
        # 配置Frame样式
        self.style.configure("Panel.TFrame", background="white")
        
        # 配置Header样式
        self.style.configure("Header.TFrame", 
                            relief="groove")
        
        # 配置按钮样式
        self.style.configure("Primary.TButton",
                            background="#ADD8E6",  # 浅蓝色作为默认背景色
                            foreground="black",
                            padding=(5, 5),
                            font=("Microsoft YaHei", 10, "bold"))

        # 设置活动状态下的背景色为蓝色
        self.style.map("Primary.TButton",
                    background=[
                        ("active", "#0000FF"),
                        ("disabled", "#A9A9A9")  # 新增：disabled状态使用灰色
                    ])
        
        # 配置普通按钮样式
        self.style.configure("General.TButton",
                            background="#ADD8E6",  # 浅蓝色作为默认背景色
                            foreground="black",
                            padding=(5, 1),
                            font=("Microsoft YaHei", 10, "bold"))
        # 设置普通按钮活动状态下的背景色为蓝色
        self.style.map("General.TButton",
                    background=[
                        ("active", "#0000FF"),
                        ("disabled", "#A9A9A9")  # 新增：disabled状态使用灰色
                    ])
        
        # 配置全选复选框样式
        self.style.configure("ToggleAll.TCheckbutton",
                            foreground="black",
                            font=("Microsoft YaHei", 10))

        self.style.map("ToggleAll.TCheckbutton",
                    background=[("disabled", "#A9A9A9")])
        
        self.style.configure("TEntry", 
                            fieldbackground="#A9A9A9",
                            font=("Microsoft YaHei", 10),
                            state="disabled")
        self.style.configure("TCombobox", 
                            fieldbackground="#A9A9A9",
                            font=("Microsoft YaHei", 10),
                            state="disabled")
        # 配置Label样式
        self.style.configure("Label.TLabel",
                            font=("Microsoft YaHei", 10),
                            foreground="black")  # 统一字体和文字颜色

        # 配置Radiobutton样式
        self.style.configure("Radio.TRadiobutton",
                            font=("Microsoft YaHei", 10),
                            foreground="black")  # 统一字体和文字颜色
        
        
    def create_tabs(self):
        """创建选项卡控件"""
        # 创建Notebook控件
        self.notebook = ttk.Notebook(self.root, style=".TNotebook")
        self.notebook.pack(fill="both", expand=True, padx=10, pady=10)
        
        # 创建三个面板
        self.check_frame = ttk.Frame(self.notebook, style="Panel.TFrame")
        self.optimize_frame = ttk.Frame(self.notebook, style="Panel.TFrame")
        self.summary_frame = ttk.Frame(self.notebook, style="Panel.TFrame")
        
        # 添加选项卡
        self.notebook.add(self.check_frame, text=" 检查 ", compound="left")
        self.notebook.add(self.optimize_frame, text=" 优化 ", compound="left")
        self.notebook.add(self.summary_frame, text=" 摘要 ", compound="left")
        
        # 绑定选项卡切换事件
        self.notebook.bind("<<NotebookTabChanged>>", self.on_tab_changed)
        
    def init_variables(self):
        """初始化变量"""

        self.surported_fonts = ["黑体", "宋体", "微软雅黑","仿宋_GB2312","楷体_GB2312"]
    
        # 文件路径变量：检查
        self.file_path_check_var = tk.StringVar()

        # 文件路径变量：优化
        self.file_path_optimize_var = tk.StringVar()

        # 文件路径变量：摘要
        self.file_path_summary_var = tk.StringVar()
        
        # 日期条件变量
        self.date_condition = tk.StringVar(value="outside")
        
        # 前景色条件变量
        self.color_condition = tk.StringVar(value="exists")

        # 背景色条件变量
        self.bgcolor_condition = tk.StringVar(value="bgexists")
        
        # 摘要类型变量
        self.summary_type = tk.StringVar(value="extractive")
        
        # 日期范围变量
        self.start_date = tk.StringVar()
        self.end_date = tk.StringVar()
        
        # 文本准确性检查项变量
        self.spell_check_var = tk.BooleanVar(value=True)  # 错别字检查
        self.punctuation_check_var = tk.BooleanVar(value=True)  # 标点符号检查
        self.grammar_check_var = tk.BooleanVar(value=True)  # 病句检查
        self.redundancy_check_var = tk.BooleanVar(value=True)  # 语句冗余检查
        self.terminology_check_var = tk.BooleanVar(value=True)  # 术语一致性检查
        # 文本准确性检查项变量列表
        self.text_check_vars = [
            self.spell_check_var,
            self.punctuation_check_var,
            self.grammar_check_var,
            self.redundancy_check_var,
            self.terminology_check_var
        ]

        self.link_check_var = tk.BooleanVar(value=True)#链接有效性检查
        self.date_check_var = tk.BooleanVar(value=False)#日期范围检查
        self.font_color_check_var = tk.BooleanVar(value=False)#字体前景色检查
        self.font_bgcolor_check_var = tk.BooleanVar(value=False)#字体背景色检查
        # 数据与合规检查项变量列表
        self.compliance_check_vars = [
            self.link_check_var,
            self.date_check_var,
        ]

        self.toggle_all_var = tk.BooleanVar(value=True)  # 文本准确性检查-全选按钮初始状态设置为：勾选
        self.toggle_all_var_compliance = tk.BooleanVar(value=False)  # 数据与合规检查-全选按钮初始状态设置为：半勾选

        # 内容优化项变量
        self.spell_optimize_var = tk.BooleanVar(value=True)  # 错别字优化
        self.punctuation_optimize_var = tk.BooleanVar(value=True)  # 标点符号优化
        self.grammar_optimize_var = tk.BooleanVar(value=True)  # 病句优化
        self.redundancy_optimize_var = tk.BooleanVar(value=True)  # 语句冗余优化
        self.terminology_optimize_var = tk.BooleanVar(value=True)  # 术语一致性优化
        self.word_optimize_var = tk.BooleanVar(value=True)  # 用词优化
        self.sentence_optimize_var = tk.BooleanVar(value=False)  # 句子结构优化
        self.readness_optimize_var = tk.BooleanVar(value=True)  # 可读性优化

        # 内容优化项变量列表
        self.content_optimize_vars = [
            self.spell_optimize_var,
            self.punctuation_optimize_var,
            self.grammar_optimize_var,
            self.redundancy_optimize_var,
            self.terminology_optimize_var,
            self.word_optimize_var,
            self.sentence_optimize_var,
            self.readness_optimize_var
        ]

        self.toggle_all_optimize_var = tk.BooleanVar(value=True)  # 内容优化-全选按钮初始状态设置为：勾选

        # 排版优化变量
        self.heading_levels_var = tk.StringVar(value="3")  # 标题数量
        self.font_family_var = tk.StringVar(value="仿宋_GB2312")  # 字体
        self.font_size_var = tk.StringVar(value="12")  # 字号
        self.font_color_var = tk.StringVar(value="#000000")  # 颜色
        self.indent_var = tk.StringVar(value="首行缩进2字符")  # 缩进
        self.spacing_var_checkbox = tk.BooleanVar(value=True)  # 段落行距
        self.line_spacing_var = tk.StringVar(value="1")  # 行距倍数

        # 标题样式变量（动态创建）
        self.heading_configs = {}
        for i in range(5):
            heading_key = f"heading_{i + 1}"
            self.heading_configs[heading_key] = {
                'font': ["黑体","黑体","黑体","黑体","黑体"][i],
                'fontsize': str([16, 14, 12, 12, 12][i]),
                'align': ["居中", "居中", "左对齐", "左对齐", "左对齐"][i],
                'bold': [1, 1, 1, 0, 0][i],
                'color': ["#000000","#000000","#000000","#000000","#000000"][i]
            }        

        self.len_control = tk.BooleanVar(value=True)  #长度控制
        self.keyword_focus_var = tk.BooleanVar(value=False)  #关键词聚焦

        self.open_file_var = tk.BooleanVar(value=True)  # 完成后打开文件：初始状态设置为：勾选
        
        # 新增双文件比较相关变量
        self.compare_files_var = tk.BooleanVar(value=False)  # 双文件比较开关
        self.output_similarity_ratio_var = tk.BooleanVar(value=True)  # 输出相似度比例
        self.output_similarity_content_var = tk.BooleanVar(value=True)  # 输出相似度内容
        self.file_path_compare1_var = tk.StringVar()  # 第一个比较文件路径
        self.file_path_compare2_var = tk.StringVar()  # 第二个比较文件路径

        self.optimize_output_file_path = "" # 优化后的文件保存路径
    def on_tab_changed(self, event):
        """选项卡切换事件处理"""
        # 获取当前选中的选项卡
        current_tab = self.notebook.select()
        tab_index = self.notebook.index(current_tab)
        print(f"切换到选项卡: {tab_index}")
        
        # 可以根据不同的选项卡执行不同的操作
        if tab_index == 0:  # 文档内容检查
            self.create_check_panel()
        elif tab_index == 1:  # 内容优化+排版
            self.create_optimize_panel()
        elif tab_index == 2:  # 文档内容摘要
            self.create_summary_panel()
    def create_check_panel(self):
        """创建文档内容检查面板"""
        # 清空现有内容
        for widget in self.check_frame.winfo_children():
            widget.destroy()
       
        # 创建检查选项区域
        options_frame = ttk.Frame(self.check_frame)
        options_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 在文本准确性模块之前插入双文件比较模块
        compare_frame = ttk.LabelFrame(options_frame, text="选择文件")
        compare_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 启用双文件比较复选框
        self.compare_toggle_checkbox = ttk.Checkbutton(
            compare_frame, text="启用双文件比较", variable=self.compare_files_var,
            style="ToggleAll.TCheckbutton",
            command=self.toggle_compare_file_visibility  # 绑定状态变化事件
        )
        self.compare_toggle_checkbox.pack(anchor="w", padx=5, pady=1)

        # 创建水平布局容器用于并列放置输出选项
        self.compare_option_frame = ttk.Frame(compare_frame)
        self.compare_option_frame.pack(fill="x", padx=20, pady=0)

        # 输出相似度比例 + 输出相似度内容（水平排列）
        self.create_checkbutton_with_label(
            self.compare_option_frame, "输出相似度比例", self.output_similarity_ratio_var, '显示文档相似度百分比').pack(side="left", padx=(0, 10), pady=0)

        self.create_checkbutton_with_label(
            self.compare_option_frame, "输出相似度内容", self.output_similarity_content_var, '显示文档差异详情').pack(side="left", padx=74, pady=0)

       # 第一个文件选择
        self.compare_file_frame = ttk.Frame(compare_frame)  # 添加实例变量引用
        self.compare_file_frame.pack(fill="x", padx=20, pady=(2,2))

        self.label_check_file = ttk.Label(self.compare_file_frame, text="基准文件", style="Label.TLabel")
        self.label_check_file.pack(side="left", padx=5)

        self.file_path_compare1_entry = ttk.Entry(self.compare_file_frame, 
            textvariable=self.file_path_compare1_var, width=50,style="TEntry",state="readonly")
        self.file_path_compare1_entry.pack(side="left", padx=5, expand=True, fill="x")

        self.file_select_button1 = ttk.Button(self.compare_file_frame, text="浏览...", 
            command=lambda: self.select_compare_file(1), style="General.TButton")
        self.file_select_button1.pack(side="left", padx=5)

        # 第二个文件选择
        self.compare_file_frame2 = ttk.Frame(compare_frame)  # 添加实例变量引用
        self.compare_file_frame2.pack(fill="x", padx=20,pady=(2,2))

        ttk.Label(self.compare_file_frame2, text="新版文件", style="Label.TLabel").pack(
            side="left", padx=5)

        self.file_path_compare2_entry = ttk.Entry(self.compare_file_frame2, 
            textvariable=self.file_path_compare2_var, width=50,style="TEntry",state="readonly")
        self.file_path_compare2_entry.pack(side="left", padx=5, expand=True, fill="x")

        self.file_select_button2 = ttk.Button(self.compare_file_frame2, text="浏览...", 
            command=lambda: self.select_compare_file(2), style="General.TButton")
        self.file_select_button2.pack(side="left", padx=5)
        
        # 初始化时更新控件可见性
        self.toggle_compare_file_visibility()

        # 创建“文本准确性”LabelFrame
        text_accuracy_frame = ttk.LabelFrame(options_frame, text="文本准确性")
        text_accuracy_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 全选按钮
        self.toggle_checkbutton = ttk.Checkbutton(
            text_accuracy_frame, text="全选", variable=self.toggle_all_var,
            command=lambda: self.toggle_all_options(self.toggle_all_var,self.text_check_vars),
            style="ToggleAll.TCheckbutton"
        )
        self.toggle_checkbutton.pack(anchor="w", padx=5, pady=2) 
        self.update_parent_checkbox(self.toggle_all_var, self.text_check_vars,self.toggle_checkbutton)

        # 创建水平布局容器
        horizontal_frames = []
        for i in range(2):  # 创建3个水平容器
            frame = ttk.Frame(text_accuracy_frame)
            frame.pack(fill="x", padx=20, pady=0)  # 横向填充保持对齐
            horizontal_frames.append(frame)

        # 错别字检查 + 标点符号检查（第1行）
        self.create_checkbutton_with_label(horizontal_frames[0], "错别字检查", self.spell_check_var,
            '自动识别并标注拼写错误（如"优化"误写为"优货"）').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[0], "标点符号检查", self.punctuation_check_var,
            '检测中英文标点混用、缺失或冗余（如句末缺少句号）').pack(side="left", padx=40, pady=0)

        # 病句检查 + 语句冗余检查（第2行）
        self.create_checkbutton_with_label(horizontal_frames[1], "病句检查", self.grammar_check_var,
            '分析语法结构，标记主谓不一致、成分残缺等病句').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[1], "语句冗余检查", self.redundancy_check_var,
            '检测重复冗余语句（如"这个产品非常好，非常好"）').pack(side="left", padx=64, pady=0)
        
        self.create_checkbutton_with_label(text_accuracy_frame, "术语一致性检查", self.terminology_check_var,'确保专业术语（如"AI"或"人工智能"）全文统一').pack(anchor="w", padx=20, pady=0)

        # 为每个子按钮的变量添加 trace，用于监听状态变化
        for var in self.text_check_vars:
            var.trace_add("write", lambda *args: self.on_child_check(
                self.text_check_vars, 
                self.toggle_all_var, 
                self.toggle_checkbutton, 
                *args
            ))

        # 数据与合规部分（保持不变）
        compliance_frame = ttk.LabelFrame(options_frame, text="数据与合规")
        compliance_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 全选按钮
        self.toggle_checkbutton_compliance = ttk.Checkbutton(
            compliance_frame, text="全选", variable=self.toggle_all_var_compliance,
            command=lambda: self.toggle_all_options(self.toggle_all_var_compliance,self.compliance_check_vars),
            style="ToggleAll.TCheckbutton"
        )
        self.toggle_checkbutton_compliance.pack(anchor="w", padx=5, pady=2) 
        self.update_parent_checkbox(self.toggle_all_var_compliance, self.compliance_check_vars,self.toggle_checkbutton_compliance)
        
        ttk.Checkbutton(compliance_frame, text="链接有效性检查", variable=self.link_check_var,style="ToggleAll.TCheckbutton").pack(anchor="w",padx=20, pady=0) 
        
        # 日期范围检查
        date_frame = ttk.Frame(compliance_frame)
        date_frame.pack(fill="x", padx=0, pady=0)
                  
        ttk.Checkbutton(date_frame, text="日期范围检查", variable=self.date_check_var,
                 command=self.toggle_date_elements,style="ToggleAll.TCheckbutton").pack(anchor="w", padx=20, pady=0)

        # 为每个子按钮的变量添加 trace，用于监听状态变化
        for var in self.compliance_check_vars:
            var.trace_add("write", lambda *args: self.on_child_check(
                self.compliance_check_vars, 
                self.toggle_all_var_compliance, 
                self.toggle_checkbutton_compliance, 
                *args
            ))
                
        # 日期条件选择
        date_cond_frame = ttk.Frame(date_frame)
        date_cond_frame.pack(fill="x", padx=30, pady=0)

        # self.radio_within = ttk.Radiobutton(date_cond_frame, text="在指定日期范围则告警",
        #                                     variable=self.date_condition, value="within",style="Radio.TRadiobutton")
        self.radio_outside = ttk.Radiobutton(date_cond_frame, text="不在指定日期范围则告警",
                                            variable=self.date_condition, value="outside",style="Radio.TRadiobutton")
        # self.radio_within.pack(anchor="w")
        self.radio_outside.pack(anchor="w")

        # 日期选择器
        date_picker_frame = ttk.Frame(date_frame)
        date_picker_frame.pack(fill="x", padx=30, pady=(0,5))

        ttk.Label(date_picker_frame, text="开始日期：",style="Label.TLabel").pack(side="left")
        self.start_date_entry = DateEntry(
            date_picker_frame,
            textvariable=self.start_date,
            width=10,
            background='darkblue',
            foreground='white',
            borderwidth=2,
            date_pattern='yyyy-mm-dd'  # 固定日期格式
        )
        self.start_date_entry.pack(side="left", padx=5, pady=0)

        ttk.Label(date_picker_frame, text="结束日期：",style="Label.TLabel").pack(side="left")
        self.end_date_entry = DateEntry(
            date_picker_frame,
            textvariable=self.end_date,
            width=10,
            background='darkblue',
            foreground='white',
            borderwidth=2,
            date_pattern='yyyy-mm-dd'  # 固定日期格式
        )
        self.end_date_entry.pack(side="left", padx=5, pady=0)

        # 日期快捷按钮
        self.date_btn_frame = ttk.Frame(date_picker_frame)
        self.date_btn_frame.pack(fill="x", padx=0, pady=0)

        ttk.Button(self.date_btn_frame, text="本周", command=self.set_week_range,style="General.TButton",
             width=6).pack(side="left", padx=2, pady=0)
        ttk.Button(self.date_btn_frame, text="上周", command=self.set_last_week_range,style="General.TButton",
             width=6).pack(side="left", padx=2, pady=0)
        ttk.Button(self.date_btn_frame, text="本月", command=self.set_month_range,style="General.TButton",
             width=6).pack(side="left", padx=2, pady=0)
        ttk.Button(self.date_btn_frame, text="上月", command=self.set_last_month_range,style="General.TButton",
             width=6).pack(side="left", padx=2, pady=0)
        ttk.Button(self.date_btn_frame, text="近三月", command=self.set_three_months_range,style="General.TButton",
             width=6).pack(side="left", padx=2, pady=0)
        
        self.toggle_date_elements()#初始化
        
        # 格式与标识部分（保持不变）
        formatting_frame = ttk.LabelFrame(options_frame, text="格式与标识")
        formatting_frame.pack(fill="both", expand=False, padx=5, pady=5)
        
        # 创建前景色和背景色检查的容器
        color_container = ttk.Frame(formatting_frame)
        color_container.pack(fill="x", padx=5, pady=0)
        
        # 字体前景色检查区域（左侧）
        left_color_frame = ttk.Frame(color_container)
        left_color_frame.pack(side="left", fill="x", expand=True, padx=0, pady=0)
        
        # 原有前景色检查组件迁移至此
        ttk.Checkbutton(left_color_frame, text="字体前景色检查",
                variable=self.font_color_check_var,
                command=self.toggle_color_elements,style="ToggleAll.TCheckbutton").pack(anchor="w", padx=0, pady=0)
        
        # 颜色条件选择（前景色）
        self.color_cond_frame = ttk.Frame(left_color_frame)
        self.color_cond_frame.pack(fill="x", padx=20, pady=0)

        self.radio_exists = ttk.Radiobutton(self.color_cond_frame, text="存在指定颜色字体则告警",
                                            variable=self.color_condition, value="exists",style="Radio.TRadiobutton")
        self.radio_not_exists = ttk.Radiobutton(self.color_cond_frame, text="不存在指定颜色字体则告警",
                                                variable=self.color_condition, value="notExists",style="Radio.TRadiobutton")
        self.radio_exists.pack(anchor="w")
        self.radio_not_exists.pack(anchor="w")

        # 颜色选择器（前景色）
        color_picker_frame = ttk.Frame(left_color_frame)
        color_picker_frame.pack(fill="x", padx=20, pady=(0,5))

        ttk.Label(color_picker_frame, text="指定颜色：",style="Label.TLabel").pack(side="left")

        # 创建颜色选择变量
        self.specified_color = tk.StringVar(value="#ff0000")

        # 创建颜色值输入框
        self.color_entry = ttk.Entry(color_picker_frame, textvariable=self.specified_color, width=10,style="TEntry")
        self.color_entry.pack(side="left")
        self.color_entry.bind("<Button-1>", lambda e: self.choose_color(self.specified_color,self.color_label))

        # 创建颜色预览标签
        self.color_label = tk.Label(color_picker_frame, text="    ",background=self.specified_color.get())
        self.color_label.pack(side="left", padx=5)
        
        # 字体背景色检查区域（右侧）
        right_color_frame = ttk.Frame(color_container)
        right_color_frame.pack(side="left", fill="x", expand=True, padx=0, pady=0)
        
        ttk.Checkbutton(right_color_frame, text="字体背景色检查",
                variable=self.font_bgcolor_check_var,
                command=self.toggle_bgcolor_elements,style="ToggleAll.TCheckbutton").pack(anchor="w", padx=0, pady=0)
        
        # 背景色条件选择
        self.bgcolor_cond_frame = ttk.Frame(right_color_frame)
        self.bgcolor_cond_frame.pack(fill="x", padx=20, pady=0)

        self.bg_radio_exists = ttk.Radiobutton(self.bgcolor_cond_frame, text="存在指定背景色字体则告警",
                                            variable=self.bgcolor_condition, value="bgexists",style="Radio.TRadiobutton")
        self.bg_radio_not_exists = ttk.Radiobutton(self.bgcolor_cond_frame, text="不存在指定背景色字体则告警",
                                                variable=self.bgcolor_condition, value="bgnotExists",style="Radio.TRadiobutton")
        self.bg_radio_exists.pack(anchor="w")
        self.bg_radio_not_exists.pack(anchor="w")

        # 背景色选择器
        bgcolor_picker_frame = ttk.Frame(right_color_frame)
        bgcolor_picker_frame.pack(fill="x", padx=20, pady=(0,5))

        ttk.Label(bgcolor_picker_frame, text="指定颜色：",style="Label.TLabel").pack(side="left")

        # 创建背景颜色选择变量
        self.specified_bgcolor = tk.StringVar(value="#ff0000")

        # 创建背景颜色值输入框
        self.bgcolor_entry = ttk.Entry(bgcolor_picker_frame, textvariable=self.specified_bgcolor, width=10,style="TEntry")
        self.bgcolor_entry.pack(side="left")
        self.bgcolor_entry.bind("<Button-1>", lambda e: self.choose_color(self.specified_bgcolor, self.bgcolor_label))

        # 创建背景颜色预览标签
        self.bgcolor_label = tk.Label(bgcolor_picker_frame, text="    ", background=self.specified_bgcolor.get())
        self.bgcolor_label.pack(side="left", padx=5)
        
        # 初始化两个颜色选择组件的状态
        self.toggle_color_elements()
        self.toggle_bgcolor_elements()

        # 创建个性化提示词输入区域
        prompt_frame = ttk.LabelFrame(options_frame, text="个性化提示词")
        prompt_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 创建多行文本框
        self.check_custom_prompt_text = tk.Text(
            prompt_frame,
            height=2,
            width=60,
            wrap="word",
            font=("Microsoft YaHei", 10)
        )
        
        # 创建滚动条
        prompt_scrollbar = ttk.Scrollbar(
            prompt_frame,
            orient="vertical",
            command=self.check_custom_prompt_text.yview
        )
        self.check_custom_prompt_text.config(yscrollcommand=prompt_scrollbar.set)
        
        # 布局组件
        self.check_custom_prompt_text.pack(side="left", fill="both", expand=True, padx=5, pady=5)
        prompt_scrollbar.pack(side="left", fill="y", padx=(0,5), pady=5)

        # 添加占位符文本
        self.check_placeholder_text = """请输入个性化提示词，例如：
1、检查"@xxx，xxx"这样的字眼是否存在
2、检查"按需反馈，更新后的内容请标黑"这样的字眼是否存在
3、检查"（填写人：xxx）"这样的字眼是否存在"""
        self.check_custom_prompt_text.insert("1.0", self.check_placeholder_text)
        self.check_custom_prompt_text.tag_add("placeholder", "1.0", "end")
        self.check_custom_prompt_text.tag_config(
            "placeholder", 
            foreground="#7f8c8d",
            font=("Microsoft YaHei", 9)
        )
        # 绑定事件
        self.check_custom_prompt_text.bind("<FocusIn>", self.on_check_prompt_focus_in)
        self.check_custom_prompt_text.bind("<FocusOut>", self.on_check_prompt_focus_out)

        # 创建开始检查按钮区域
        start_check_frame = ttk.Frame(self.check_frame)
        start_check_frame.pack(fill="both", expand=False, padx=5, pady=2)
        
        # 创建开始检查按钮
        ttk.Button(start_check_frame, text="开始检查", 
                style="Primary.TButton", command=self.check_document).pack(
            side="right", padx=10, pady=5)
        
    def toggle_date_elements(self):
        state = "normal" if self.date_check_var.get() == 1 else "disabled"
        # self.radio_within.config(state=state)
        self.radio_outside.config(state=state)
        self.start_date_entry.config(state=state)
        self.end_date_entry.config(state=state)
        for child in self.date_btn_frame.winfo_children():  
            child.config(state=state)     

    def toggle_color_elements(self):
        state = "normal" if self.font_color_check_var.get() == 1 else "disabled"
        self.radio_exists.config(state=state)
        self.radio_not_exists.config(state=state)
        self.color_entry.config(state=state)
        self.color_label.config(state=state)   
        
    def toggle_bgcolor_elements(self):
        state = "normal" if self.font_bgcolor_check_var.get() == 1 else "disabled"
        self.bg_radio_exists.config(state=state)
        self.bg_radio_not_exists.config(state=state)
        self.bgcolor_entry.config(state=state)
        self.bgcolor_label.config(state=state)   
    
    def toggle_all_options(self, var,sub_vars):
        """切换全选状态"""
        state = var.get()
        # 仅更新文本准确性相关的检查项
        for v in sub_vars:
            v.set(state)
        
    def select_file(self, file_type=None):
        """选择文件对话框"""
        file_path = filedialog.askopenfilename(
            filetypes=[("Word文档", "*.docx")])
        if file_path:
            if file_type == 'check':
                self.file_path_check_var.set(file_path)
            elif file_type == 'optimize':
                self.file_path_optimize_var.set(file_path)
            elif file_type == 'summary':
                self.file_path_summary_var.set(file_path)
        
    def select_compare_file(self, file_index):
        """选择对比文件"""
        file_path = filedialog.askopenfilename(
            filetypes=[("Word文档", "*.docx")])
        if file_path:
            if file_index == 1:
                self.file_path_compare1_var.set(file_path)
            else:  # file_index == 2:
                self.file_path_compare2_var.set(file_path)

    def check_document(self):                
        config = {
            # 错别字检查：检查文档中的拼写错误
            'spell_check': self.spell_check_var.get(),
            # 标点符号检查：检查中英文标点混用、缺失或冗余问题
            'punctuation_check': self.punctuation_check_var.get(),
            # 病句检查：分析语法结构，标记主谓不一致等语法问题
            'grammar_check': self.grammar_check_var.get(),
            # 语句冗余检查：检测重复冗余语句
            'redundancy_check': self.redundancy_check_var.get(),
            # 术语一致性检查：确保专业术语全文统一
            'terminology_check': self.terminology_check_var.get(),
            # 链接有效性检查：验证文档中超链接是否有效
            'link_check': self.link_check_var.get(),
            # 日期范围检查：检查日期是否在指定范围内
            'date_check': self.date_check_var.get(),
            # 字体颜色检查：检查字体前景色是否符合要求
            'font_color_check': self.font_color_check_var.get(),
            # 字体背景色检查：检查字体背景色是否符合要求
            'font_bgcolor_check': self.font_bgcolor_check_var.get(),
            # 日期条件：日期检查的条件（在范围内/不在范围内）
            'date_condition': self.date_condition.get(),
            # 开始日期：日期范围检查的起始日期
            'start_date': self.start_date.get(),
            # 结束日期：日期范围检查的截止日期
            'end_date': self.end_date.get(),
            # 颜色条件：字体颜色检查的条件（存在/不存在指定颜色）
            'color_condition': self.color_condition.get(),
            # 背景色条件：字体背景色检查的条件（存在/不存在指定背景色）
            'bgcolor_condition': self.bgcolor_condition.get(),
            # 指定颜色：需要检查的特定字体颜色
            'specified_color': self.specified_color.get(),
            # 指定背景色：需要检查的特定字体背景色
            'specified_bgcolor': self.specified_bgcolor.get(),
            # 双文件比较：是否启用双文件比较功能
            'compare_files_check': self.compare_files_var.get(),
            # 输出相似度比例：是否输出文档相似度百分比
            'output_similarity_ratio_check': self.output_similarity_ratio_var.get(),
            # 输出相似度内容：是否输出文档差异详情
            'output_similarity_content_check': self.output_similarity_content_var.get(),
            # 基准文件路径：双文件比较的第一个文件路径
            'file_path_compare1': self.file_path_compare1_var.get(),
            # 新版文件路径：双文件比较的第二个文件路径
            'file_path_compare2': self.file_path_compare2_var.get(),
            # 个性化提示词
            'check_custom_prompt': self.check_custom_prompt_text.get("1.0", "end-1c"),
            'check_custom_prompt_placeholder': self.check_placeholder_text#个性化提示词占位符
        }
        wordChecker = WordChecker(self.root)        
        wordChecker.check(config)
        
    def create_optimize_panel(self):
        """创建内容优化面板"""
        # 清空现有内容
        for widget in self.optimize_frame.winfo_children():
            widget.destroy()
        
        # 创建文件选择区域（与检查面板类似）
        file_frame = ttk.Frame(self.optimize_frame, style="Header.TFrame")
        file_frame.pack(fill="x", padx=5, pady=5)
        
        ttk.Label(file_frame, text="选择Word文档", 
                font=("Microsoft YaHei", 10),style="Label.TLabel").pack(side="left", padx=10)
        
        ttk.Entry(file_frame, textvariable=self.file_path_optimize_var, 
                width=50,style="TEntry",state="readonly").pack(side="left", padx=5, expand=True, fill="x")
        
        ttk.Button(file_frame, text="浏览...", 
                command=lambda: self.select_file('optimize'),  # 添加参数
                style="Primary.TButton").pack(side="left", padx=5)
        
        # 创建优化选项区域
        options_frame = ttk.Frame(self.optimize_frame)
        options_frame.pack(fill="both", expand=True, padx=5, pady=5)

        content_optimize_frame = ttk.LabelFrame(options_frame, text="内容优化")
        content_optimize_frame.pack(fill="both", expand=False, padx=5, pady=5)
        
        # 全选按钮
        self.toggle_optimize_button = ttk.Checkbutton(
            content_optimize_frame, text="全选", variable=self.toggle_all_optimize_var,
            command=lambda: self.toggle_all_options(self.toggle_all_optimize_var,self.content_optimize_vars),
            style="ToggleAll.TCheckbutton"
        )
        self.toggle_optimize_button.pack(anchor="w", padx=5, pady=(0,0)) 
        self.update_parent_checkbox(self.toggle_all_optimize_var, self.content_optimize_vars,self.toggle_optimize_button)

        # 创建水平布局容器
        horizontal_frames = []
        for i in range(4):  # 创建3个水平容器
            frame = ttk.Frame(content_optimize_frame)
            frame.pack(fill="x", padx=20, pady=0)  # 横向填充保持对齐
            horizontal_frames.append(frame)

        # 错别字优化 + 用词优化（第1行）
        self.create_checkbutton_with_label(horizontal_frames[0], "错别字优化", self.spell_optimize_var,
            '自动识别并标注拼写错误（如"优化"误写为"优货"）').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[0], "用词优化", self.word_optimize_var,
            '替换模糊词汇为精准术语（如"快"优化为"高效"）').pack(side="left", padx=50, pady=0)

        # 标点符号优化 + 句子结构优化（第2行）
        self.create_checkbutton_with_label(horizontal_frames[1], "标点符号优化", self.punctuation_optimize_var,
            '检测中英文标点混用、缺失或冗余（如句末缺少句号）').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[1], "句子结构优化", self.sentence_optimize_var,
            '简化长句、调整语序以提升流畅度').pack(side="left", padx=22, pady=0)

        # 病句优化 + 可读性优化（第3行）
        self.create_checkbutton_with_label(horizontal_frames[2], "病句优化", self.grammar_optimize_var,
            '分析语法结构，标记主谓不一致、成分残缺等病句').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[2], "可读性优化", self.readness_optimize_var,
            '自动分段、添加过渡句，优化逻辑连贯性').pack(side="left", padx=74, pady=0)
        
        # 语句冗余优化 + 术语一致性优化（第4行）
        self.create_checkbutton_with_label(horizontal_frames[3], "语句冗余优化", self.redundancy_optimize_var,
            '优化重复冗余语句（如"这个产品非常好，非常好"）').pack(side="left", padx=(0, 10), pady=0)
        self.create_checkbutton_with_label(horizontal_frames[3], "术语一致性优化", self.terminology_optimize_var,
            '确保专业术语（如"AI"或"人工智能"）全文统一').pack(side="left", padx=36, pady=0)

        # 为每个子按钮的变量添加 trace，用于监听状态变化
        for var in self.content_optimize_vars:
            var.trace_add("write", lambda *args: self.on_child_check(
                self.content_optimize_vars, 
                self.toggle_all_optimize_var, 
                self.toggle_optimize_button, 
                *args
            ))        
        
        # 创建排版优化区域
        layout_frame = ttk.LabelFrame(options_frame, text="排版优化")
        layout_frame.pack(fill="both", expand=False, padx=5, pady=3)
        self.layout_frame = layout_frame  # 保存layout_frame引用用于控件状态管理

        # 添加启用排版优化复选框
        self.enable_layout_var = tk.BooleanVar(value=True)
        # enable_checkbutton = ttk.Checkbutton(layout_frame, 
        #                text="启用排版优化",
        #                variable=self.enable_layout_var,
        #                command=self.update_layout_controls,
        #                style="ToggleAll.TCheckbutton")
        # enable_checkbutton.pack(anchor="w", padx=5, pady=2)
        # self.enable_layout_checkbutton = enable_checkbutton  # 保存复选框引用

        # 标题设置区域
        font_settings_frame = ttk.LabelFrame(layout_frame, text="标题设置")
        font_settings_frame.pack(fill="x", padx=5, pady=1)

        # 标题数量设置
        heading_frame = ttk.Frame(font_settings_frame)
        heading_frame.pack(fill="x", padx=10, pady=1)
                
        ttk.Label(heading_frame, text="标题数量：",style="Label.TLabel").pack(side="left")
                
        self.heading_levels = ttk.Combobox(heading_frame, textvariable=self.heading_levels_var,
                                    values=["1", "2", "3", "4", "5"], state="readonly",width=5)
        self.heading_levels.pack(side="left", padx=5)
        self.heading_levels.bind("<<ComboboxSelected>>", lambda e: self.update_heading_settings())

        # 标题样式设置
        self.font_levels_canvas = tk.Canvas(font_settings_frame,height=110)
        self.font_levels_canvas.pack(side="left", fill="both", expand=False)

        # 添加垂直滚动条
        scrollbar = ttk.Scrollbar(font_settings_frame, orient="vertical", command=self.font_levels_canvas.yview)
        scrollbar.pack(side="right", fill="y")

        # 配置Canvas滚动属性
        self.font_levels_canvas.configure(yscrollcommand=scrollbar.set)
        self.font_levels_canvas.bind('<Configure>', lambda e: self.font_levels_canvas.configure(scrollregion=self.font_levels_canvas.bbox("all")))

        # 创建内部容器框架
        self.font_levels_container = ttk.Frame(self.font_levels_canvas)
        self.font_levels_canvas.create_window((0,0), window=self.font_levels_container, anchor="nw")
        
        # 初始化标题设置
        self.update_heading_settings()
        
        # 正文设置
        content_frame = ttk.LabelFrame(layout_frame, text="正文设置")
        content_frame.pack(fill="x", padx=5, pady=1)
        
        # 字体选择
        font_opt_frame = ttk.Frame(content_frame)
        font_opt_frame.pack(fill="x", padx=5, pady=3)
        
        # 字体选择，默认值设为"仿宋_GB2312"
        ttk.Label(font_opt_frame, text="字体：",style="Label.TLabel").pack(side="left")
        font_combobox = ttk.Combobox(font_opt_frame, values=self.surported_fonts, state="readonly", width=15, textvariable=self.font_family_var)
        font_combobox.pack(side="left", padx=5)
        font_combobox.set(self.font_family_var.get())  # 设置默认字体

        # 字号选择，默认值设为"12"
        ttk.Label(font_opt_frame, text="字号：",style="Label.TLabel").pack(side="left",)
        fontsize_spinbox = ttk.Spinbox(font_opt_frame, from_=8, to=72, width=5, textvariable=self.font_size_var)
        fontsize_spinbox.pack(side="left", padx=5)
        fontsize_spinbox.set(self.font_size_var.get())  # 设置默认字号

        # 颜色选择，默认值设为"#000000"
        ttk.Label(font_opt_frame, text="颜色：",style="Label.TLabel").pack(side="left")
        color_entry = ttk.Entry(font_opt_frame, textvariable=self.font_color_var, width=10,style="TEntry")
        color_entry.pack(side="left")
        color_entry.bind("<Button-1>", lambda e: self.choose_color(self.font_color_var, color_label))

        # 创建颜色预览标签
        color_label = tk.Label(font_opt_frame, text="  ",background=self.font_color_var.get())
        color_label.pack(side="left", padx=5)

        # 缩进选择，默认值设为"首行缩进2字符"
        ttk.Label(font_opt_frame, text="缩进：",style="Label.TLabel").pack(side="left")
        indent_combobox = ttk.Combobox(font_opt_frame, values=["无缩进", "首行缩进2字符"], state="readonly", width=15, textvariable=self.indent_var)
        indent_combobox.pack(side="left", padx=5)
        indent_combobox.set(self.indent_var.get())  # 设置默认缩进选项
        
        # 行距设置
        spacing_frame = ttk.LabelFrame(layout_frame,text="段落设置")
        spacing_frame.pack(fill="x", padx=5, pady=5)
        
        # 在 spacing_frame 中创建 Checkbutton 并设置默认选中
        ttk.Checkbutton(spacing_frame, text="段落行距", variable=self.spacing_var_checkbox,style="ToggleAll.TCheckbutton",command=self.toggle_spacing_combobox).pack(anchor="w")

        ttk.Label(spacing_frame, text="行距倍数：",style="Label.TLabel").pack(side="left", padx=20,pady=(0, 10))
        self.line_spacing_combobox = ttk.Combobox(
            spacing_frame, values=["1", "1.2", "1.5", "2"], state="readonly", width=5,
            textvariable=self.line_spacing_var
        )
        self.line_spacing_combobox.pack(side="left")
        self.line_spacing_combobox.set(self.line_spacing_var.get())  # 默认选择
        self.toggle_spacing_combobox()#  初始调用一次

        # 创建个性化提示词输入区域
        prompt_frame = ttk.LabelFrame(options_frame, text="个性化提示词")
        prompt_frame.pack(fill="both", expand=False, padx=5, pady=5)

        # 创建多行文本框
        self.custom_prompt_text = tk.Text(
            prompt_frame,
            height=4,
            width=60,
            wrap="word",
            font=("Microsoft YaHei", 10)
        )
        
        # 创建滚动条
        prompt_scrollbar = ttk.Scrollbar(
            prompt_frame,
            orient="vertical",
            command=self.custom_prompt_text.yview
        )
        self.custom_prompt_text.config(yscrollcommand=prompt_scrollbar.set)
        
        # 布局组件
        self.custom_prompt_text.pack(side="left", fill="both", expand=True, padx=5, pady=5)
        prompt_scrollbar.pack(side="left", fill="y", padx=(0,5), pady=5)

        # 添加占位符文本
        self.placeholder_text = """请输入个性化提示词，例如：
1、删除@xxx，xxx或空白的内容；
2、删除正文空白的标题行；
3、删除（填写人：xxx）之后的整行内容，如：（填写人：李泽丽、刘学巍）（更新后的内容请标黑）
        """
        self.custom_prompt_text.insert("1.0", self.placeholder_text)
        self.custom_prompt_text.tag_add("placeholder", "1.0", "end")
        self.custom_prompt_text.tag_config(
            "placeholder", 
            foreground="#7f8c8d",
            font=("Microsoft YaHei", 9)
        )
        # 绑定事件
        self.custom_prompt_text.bind("<FocusIn>", self.on_prompt_focus_in)
        self.custom_prompt_text.bind("<FocusOut>", self.on_prompt_focus_out)

        # 创建开始检查按钮区域
        start_optimize_frame = ttk.Frame(self.optimize_frame)
        start_optimize_frame.pack(fill="both", expand=False, padx=5, pady=2)

        self.file_path_button = ttk.Button(
            start_optimize_frame,
            text="输出文件路径",
            style="General.TButton",
            command=self.select_optimize_output_file_path
        )
        self.file_path_button.pack(side="left", padx=5)

        self.file_path_label_optimize = ttk.Label(
            start_optimize_frame,
            text=self.optimize_output_file_path,
            width=60,
            style="Label.TLabel"
        )
        self.file_path_label_optimize.pack(side="left", padx=5)

        self.open_file_checkbutton = ttk.Checkbutton(
            start_optimize_frame, 
            text="完成后打开", 
            variable=self.open_file_var,
            style="ToggleAll.TCheckbutton"
        )
        self.open_file_checkbutton.pack(side="left", padx=5)

        self.start_button = ttk.Button(
            start_optimize_frame, 
            text="开始优化", 
            style="Primary.TButton", 
            command=self.optimize_document
        )
        self.start_button.pack(side="right", padx=(0,10),pady=5)
    def on_prompt_focus_in(self, event):
        """当输入框获得焦点时触发"""
        if self.custom_prompt_text.get("1.0", "end-1c") == self.placeholder_text:
            self.custom_prompt_text.delete("1.0", "end")
            self.custom_prompt_text.tag_config("placeholder", foreground="#000000")

    def on_prompt_focus_out(self, event):
        """当输入框失去焦点时触发"""
        if self.custom_prompt_text.get("1.0", "end-1c") == "":
            self.custom_prompt_text.insert("1.0", self.placeholder_text)
            self.custom_prompt_text.tag_add("placeholder", "1.0", "end")
            self.custom_prompt_text.tag_config(
                "placeholder", 
                foreground="#7f8c8d",
                font=("Microsoft YaHei", 9)
            )

    def on_check_prompt_focus_in(self, event):
        """当输入框获得焦点时触发"""
        if self.check_custom_prompt_text.get("1.0", "end-1c") == self.check_placeholder_text:
            self.check_custom_prompt_text.delete("1.0", "end")
            self.check_custom_prompt_text.tag_config("placeholder", foreground="#000000")

    def on_check_prompt_focus_out(self, event):
        """当输入框失去焦点时触发"""
        if self.check_custom_prompt_text.get("1.0", "end-1c") == "":
            self.check_custom_prompt_text.insert("1.0", self.check_placeholder_text)
            self.check_custom_prompt_text.tag_add("placeholder", "1.0", "end")
            self.check_custom_prompt_text.tag_config(
                "placeholder", 
                foreground="#7f8c8d",
                font=("Microsoft YaHei", 9)
            )
    def update_layout_controls(self):
        """
        更新排版优化区域所有控件的启用状态
        当启用排版优化复选框勾选时，所有控件可编辑；
        未勾选时，所有控件禁用但仍保留用户设置值。
        """
        def set_widget_state(widget, state):
            """
            递归设置控件及其子控件的状态
            Args:
                widget: 需要设置状态的控件
                state: 状态值 (True表示启用，False表示禁用)
            """
            # 排除启用排版优化复选框本身
            if widget == self.enable_layout_checkbutton:
                return

            # 处理不同控件类型的状态设置
            if widget.winfo_class() in ['TEntry', 'TCombobox', 'TSpinbox']:
                widget.configure(state='normal' if state else 'disabled')
            elif hasattr(widget, 'state') and callable(widget.state):
                if state:
                    widget.state(['!disabled'])  # 启用控件
                else:
                    widget.state(['disabled'])  # 禁用控件
            elif isinstance(widget, (tk.Canvas, tk.LabelFrame, ttk.LabelFrame)):
                # 对Canvas和LabelFrame特殊处理
                widget.configure(state='normal' if state else 'disabled')
            
            # 递归处理子控件
            for child in widget.winfo_children():
                set_widget_state(child, state)

        # 获取启用状态
        enable_state = self.enable_layout_var.get()
        # 更新所有子控件状态
        for child in self.layout_frame.winfo_children():
            set_widget_state(child, enable_state)

    def toggle_spacing_combobox(self):
        """切换行距设置下拉框状态"""
        # 原有逻辑加上排版优化启用状态的判断
        self.line_spacing_combobox.configure(
            state='normal' if (self.spacing_var_checkbox.get() and self.enable_layout_var.get()) else 'disabled'
        )

    def update_heading_settings(self):
        """更新标题设置"""
        levels = int(self.heading_levels_var.get())
        headings = ["一级标题", "二级标题", "三级标题", "四级标题", "五级标题"]
        fonts = self.surported_fonts
        aligns = ["左对齐", "居中", "右对齐"]

        # 清空现有内容
        for widget in self.font_levels_container.winfo_children():
            widget.destroy()

        # 直接使用levels进行循环
        for i in range(levels):
            heading_key = f"heading_{i + 1}"
            level_frame = ttk.Frame(self.font_levels_container)
            
            # 布局初始化（原条件判断已移除）
            level_frame.pack(fill="x", padx=5, pady=2)
            ttk.Label(level_frame, text=headings[i],style="Label.TLabel").pack(side="left")

            # 创建独立的配置更新函数（使用闭包保持当前i值）
            def create_config_updater(current_key):
                def update_config():
                    # 确保获取最新的控件值
                    self.heading_configs[current_key] = {
                        'font': font_combobox.get(),
                        'fontsize': fontsize_spinbox.get(),
                        'align': align_combobox.get(),
                        'bold': bold_var.get(),
                        'color': color_var.get()
                    }
                return update_config

            # 为当前标题创建独立的更新函数
            update_config = create_config_updater(heading_key)

            # 字体下拉框
            font_combobox = ttk.Combobox(level_frame, values=fonts, state="readonly", width=16)
            font_combobox.pack(side="left", padx=5)

            # 获取当前配置
            config = self.heading_configs.get(heading_key, {})

            # 设置字体
            if 'font' in config:
                try:
                    font_combobox.current(fonts.index(config['font']))
                except ValueError:
                    font_combobox.set(config['font'])
            else:
                try:
                    font_combobox.current(fonts.index("黑体"))
                except ValueError:
                    font_combobox.current(0)

            # 字号选择框
            fontsize_spinbox = ttk.Spinbox(level_frame, from_=8, to=72, width=5)
            fontsize_spinbox.pack(side="left", padx=5)

            default_fontsize = "12"
            if i == 0:
                default_fontsize = "16"
            elif i == 1:
                default_fontsize = "14"

            current_fontsize = config.get('fontsize', default_fontsize)
            fontsize_spinbox.delete(0, "end")
            fontsize_spinbox.insert(0, current_fontsize)

            # 对齐方式
            align_combobox = ttk.Combobox(level_frame, values=aligns, state="readonly", width=8)
            align_combobox.pack(side="left", padx=5)

            default_align = "居中" if i <= 1 else "左对齐"
            current_align = config.get('align', default_align)
            if current_align in aligns:
                align_combobox.current(aligns.index(current_align))
            else:
                align_combobox.current(aligns.index(default_align))

            # 颜色输入框（提前定义，避免 lambda 引用未定义变量）
            color_var = tk.StringVar()
            current_color = config.get('color', "#000000")
            color_var.set(current_color)

            # 粗体复选框
            bold_var = tk.IntVar()
            current_bold = int(config.get('bold', 1 if i <= 2 else 0))
            bold_var.set(current_bold)

            # 使用 command 替代 ButtonRelease-1，确保状态变化即刻触发更新
            bold_checkbutton = ttk.Checkbutton(
                level_frame,
                text="粗体",
                variable=bold_var,
                style="ToggleAll.TCheckbutton",
                command=lambda key=heading_key, fc=font_combobox, fs=fontsize_spinbox,
                            ac=align_combobox, bv=bold_var, cv=color_var:
                    self.heading_configs.__setitem__(
                        key, {
                            'font': fc.get(),
                            'fontsize': fs.get(),
                            'align': ac.get(),
                            'bold': bv.get(),
                            'color': cv.get()
                        }
                    )
            )
            bold_checkbutton.pack(side="left", padx=5)

            # 创建颜色预览标签
            color_label = tk.Label(level_frame, text="  ",background=color_var.get())

            # 颜色输入框（绑定事件）
            color_entry = ttk.Entry(level_frame, textvariable=color_var, width=8,style="TEntry")
            color_entry.pack(side="left", padx=5)
            color_entry.bind("<Button-1>", lambda e, var=color_var, entry=color_label: self.choose_color(var, entry))
            
            color_label.pack(side="left", padx=5)

            # 绑定控件变化事件（使用闭包保持当前值）
            font_combobox.bind(
                "<<ComboboxSelected>>", 
                lambda e, key=heading_key: update_config()
            )
            fontsize_spinbox.bind(
                "<FocusOut>", 
                lambda e, key=heading_key: update_config()
            )
            align_combobox.bind(
                "<<ComboboxSelected>>", 
                lambda e, key=heading_key: update_config()
            )
            color_entry.bind(
                "<FocusOut>", 
                lambda e, key=heading_key: update_config()
            )

            # 初始写入一次
            update_config()

             # 更新滚动区域
        self.font_levels_container.update_idletasks()
        canvas_height = self.font_levels_container.winfo_height()
        self.font_levels_canvas.configure(scrollregion=(0, 0, self.font_levels_container.winfo_reqwidth(), canvas_height),width=900)
        

    def choose_color(self, color_var=None, color_widget=None):
        """选择颜色对话框"""
        from tkinter import colorchooser
        import time  # 添加时间模块导入

        if color_var is None:
            color_var = tk.StringVar(value="#ff0000")

        color_code = colorchooser.askcolor(title="选择颜色", initialcolor=color_var.get())

        if color_code[1]:
            color_var.set(color_code[1])            
            if color_widget is not None:                
                color_widget.configure(bg=color_code[1])       

    def optimize_document(self):
        """执行文档优化
        收集所有优化选项卡中的配置项，传递给WordOptimizer进行文档处理
        
        参数说明：
        无显式参数，但使用类实例变量收集配置
        
        返回值：
        无
        
        异常处理：
        无显式异常处理，但WordOptimizer内部应处理操作异常
        """
        # 收集标题样式配置
        heading_config = {}
        for i in range(1, int(self.heading_levels_var.get()) + 1):
            heading_key = f'heading_{i}'
            heading_config[heading_key] = {
                'font': self.heading_configs[heading_key]['font'],
                'fontsize': self.heading_configs[heading_key]['fontsize'],
                'align': self.heading_configs[heading_key]['align'],
                'bold': self.heading_configs[heading_key]['bold'],
                'color': self.heading_configs[heading_key]['color']
            }
        
        # 收集所有优化配置项
        config = {
            'file_path_optimize': self.file_path_optimize_var.get(), # 选择的文件路径
            
            # 内容优化选项配置
            'spell_optimize': self.spell_optimize_var.get(),  # 是否启用错别字优化功能
            'punctuation_optimize': self.punctuation_optimize_var.get(),  # 是否启用标点符号优化功能
            'grammar_optimize': self.grammar_optimize_var.get(),  # 是否启用病句优化功能
            'redundancy_optimize': self.redundancy_optimize_var.get(),  # 是否启用语句冗余优化功能
            'terminology_optimize': self.terminology_optimize_var.get(),  # 是否启用术语一致性优化功能
            'word_optimize': self.word_optimize_var.get(),  # 是否启用用词优化功能
            'sentence_optimize': self.sentence_optimize_var.get(),  # 是否启用句子结构优化功能
            'readness_optimize': self.readness_optimize_var.get(),  # 是否启用可读性优化功能

            'enable_layout_check': self.enable_layout_var.get(),#启用排版优化功能
            # 排版优化选项配置
            'font_family': self.font_family_var.get(),  # 选择的正文字体名称（如"仿宋_GB2312"）
            'font_size': self.font_size_var.get(),  # 选择的正文字号大小（如"12"）
            'font_color': self.font_color_var.get(),  # 选择的正文字体颜色（十六进制值，如"#000000"）
            'indent': self.indent_var.get(),  # 选择的缩进方式（如"首行缩进2字符"）
            'spacing_enabled': self.spacing_var_checkbox.get(),  # 是否启用段落行距调整
            'line_spacing': self.line_spacing_var.get(),  # 行距倍数设置（如"1"、"1.5"等）
            
            # 标题设置层级
            'heading_levels': self.heading_levels_var.get(),
            
            # 个性化提示词
            'custom_prompt': self.custom_prompt_text.get("1.0", "end-1c"),
            'custom_prompt_placeholder': self.placeholder_text,#个性化提示词占位符

            'optimize_output_file_path': self.optimize_output_file_path, # 优化后的文件保存路径
            
            # 文件优化完成后是否打开
            'open_file_after_completion': self.open_file_var.get(),
            
            # 标题样式配置
            **heading_config
        }
        
        # 调用优化器执行优化
        wordOptimizer = WordOptimizer(self.root)
        wordOptimizer.optimize(config)
        
    def set_week_range(self):
        """设置本周日期范围"""
        import datetime
        today = datetime.date.today()
        start = today - datetime.timedelta(days=today.weekday())
        end = start + datetime.timedelta(days=6)
        self.start_date.set(start.strftime("%Y-%m-%d"))
        self.end_date.set(end.strftime("%Y-%m-%d"))
        
    def set_last_week_range(self):
        """设置上周日期范围"""
        import datetime
        today = datetime.date.today()
        start = today - datetime.timedelta(days=today.weekday() + 7)
        end = start + datetime.timedelta(days=6)
        self.start_date.set(start.strftime("%Y-%m-%d"))
        self.end_date.set(end.strftime("%Y-%m-%d"))
        
    def set_month_range(self):
        """设置本月日期范围"""
        import datetime
        today = datetime.date.today()
        start = datetime.date(today.year, today.month, 1)
        
        # 计算下个月的第一天（考虑12月跨年情况）
        if today.month == 12:
            next_month_start = datetime.date(today.year + 1, 1, 1)
        else:
            next_month_start = datetime.date(today.year, today.month + 1, 1)
        
        # 当前月最后一天 = 下个月第一天 - 1天
        end = next_month_start - datetime.timedelta(days=1)
        
        self.start_date.set(start.strftime("%Y-%m-%d"))
        self.end_date.set(end.strftime("%Y-%m-%d"))
        
    def set_last_month_range(self):
        """设置上月日期范围"""
        import datetime
        today = datetime.date.today()
        last_month = (datetime.date(today.year, today.month, 1) - 
                     datetime.timedelta(days=1))
        start = datetime.date(last_month.year, last_month.month, 1)
        end = last_month.replace(day=28) + datetime.timedelta(days=4) - datetime.timedelta(days=1)
        self.start_date.set(start.strftime("%Y-%m-%d"))
        self.end_date.set(end.strftime("%Y-%m-%d"))
        
    def set_three_months_range(self):
        """设置近三个月日期范围"""
        import datetime
        today = datetime.date.today()
        three_months_ago = today - datetime.timedelta(days=90)
        self.start_date.set(three_months_ago.strftime("%Y-%m-%d"))
        self.end_date.set(today.strftime("%Y-%m-%d"))
        
    def create_summary_panel(self):
        """创建文档摘要面板"""
        # 清空现有内容
        for widget in self.summary_frame.winfo_children():
            widget.destroy()
        
        # 创建文件选择区域（与前面的面板类似）
        file_frame = ttk.Frame(self.summary_frame, style="Header.TFrame")
        file_frame.pack(fill="x", padx=5, pady=5)
        
        ttk.Label(file_frame, text="选择Word文档", 
                  font=("Microsoft YaHei", 10),style="Label.TLabel").pack(side="left", padx=10)
        
        ttk.Entry(file_frame, textvariable=self.file_path_summary_var, 
                 width=50,style="TEntry",state="readonly").pack(side="left", padx=5, expand=True, fill="x")
        
        ttk.Button(file_frame, text="浏览...", 
                command=lambda: self.select_file('summary'),  # 添加参数
                style="Primary.TButton").pack(side="left", padx=5)
        
        # 创建摘要选项区域
        options_frame = ttk.Frame(self.summary_frame)
        options_frame.pack(fill="both", padx=5, pady=5)
        
        
        creation_mode_frame = ttk.LabelFrame(options_frame,text="摘要生成模式")
        creation_mode_frame.pack(fill="both", padx=5, pady=5)
        
        # 创建四个单选按钮并设置默认值
        self.summary_type.set("quick")  # 设置默认值

        self.create_radio_with_label(creation_mode_frame, "快速摘要", "quick", "一键生成简化版摘要").pack(
            anchor="w", padx=10, pady=2)
        self.create_radio_with_label(creation_mode_frame, "抽取式摘要", "extractive", "直接提取原文关键句子（保留原句结构）").pack(
            anchor="w", padx=10, pady=2)
        self.create_radio_with_label(creation_mode_frame, "生成式摘要", "generative", "AI重写核心内容，生成新表述").pack(
            anchor="w", padx=10, pady=2)
        self.create_radio_with_label(creation_mode_frame, "混合式摘要", "hybrid", "结合抽取与生成，平衡准确性与简洁性").pack(
            anchor="w", padx=10, pady=2)
        
        # 摘要参数设置
        params_frame = ttk.LabelFrame(options_frame, text="摘要参数设置")
        params_frame.pack(fill="both", padx=5, pady=5)

        # 位置设置
        position_frame = ttk.Frame(params_frame)
        position_frame.pack(fill="x", padx=5, pady=5)
                
        ttk.Label(position_frame, text="摘要位置",style="Label.TLabel").pack(anchor="w",padx=5, pady=5)
        
        # 创建 Combobox 并设置默认选中第一个选项
        self.summary_location_combo = ttk.Combobox(
            position_frame,
            values=["插入原文档顶端", "插入原文档末尾", "新建独立文档"],
            state="readonly",
            width=20
        )
        self.summary_location_combo.pack(side="left", padx=20)
        self.summary_location_combo.current(0)  # 设置默认选中第一个选项（索引为0）
        self.summary_location_combo.bind("<<ComboboxSelected>>", lambda event: self.on_combobox_change(self.summary_location_combo.get()))

        self.file_path_button = ttk.Button(
            position_frame,            
            text="命名新文件",
            style="General.TButton",
            command=self.select_file_path,            
            state="hidden"
        )
        self.file_path_button.pack(side="left", ipady=3,padx=5)

        self.file_path_label = ttk.Label(
            position_frame,
            text="",
            width=60,
            style="Label.TLabel"
        )
        self.file_path_label.pack(side="left", padx=5)

        self.file_path_button.pack_forget()
        self.file_path_label.pack_forget()
        
        # 长度控制
        length_frame = ttk.Frame(params_frame)
        length_frame.pack(fill="x", padx=5, pady=5)
        
        ttk.Checkbutton(length_frame, text="长度控制",variable=self.len_control,style="ToggleAll.TCheckbutton").pack(anchor="w")        
        
        control_frame = ttk.Frame(length_frame)
        control_frame.pack(fill="x", padx=20, pady=5)
        
        ttk.Label(control_frame, text="控制方式：",style="Label.TLabel").pack(side="left")
        self.control_method_combo = ttk.Combobox(
            control_frame, 
            values=["按字数","按比例", "按句数"],
            state="readonly", 
            width=12
        )
        self.control_method_combo.pack(side="left", padx=5)
        self.control_method_combo.bind("<<ComboboxSelected>>", self.on_control_method_change)
        self.control_method_combo.current(0)  # 设置默认选择第一个选项
        
        ttk.Label(control_frame, text="长度值：",style="Label.TLabel").pack(side="left", padx=5)
        self.length_entry = ttk.Entry(control_frame, width=10,style="TEntry")
        self.length_entry.pack(side="left") 

        self.label_len_desp = ttk.Label(control_frame, text="",style="Label.TLabel")
        self.label_len_desp.pack(side="left", padx=2)
        # 初始化时触发一次事件
        self.on_control_method_change()
        self.len_control.trace_add("write", self.update_length_controls_state)
        self.update_length_controls_state()  # 初始化状态
        
        # 关键词聚焦
        keyword_frame = ttk.Frame(params_frame)
        keyword_frame.pack(fill="x", padx=5, pady=5)
        
        ttk.Checkbutton(keyword_frame, text="关键词聚焦",variable=self.keyword_focus_var,style="ToggleAll.TCheckbutton").pack(anchor="w")
        
        # 创建容器frame用于分组
        include_exclude_frame = ttk.Frame(keyword_frame)
        include_exclude_frame.pack(fill="x", pady=2)

        # 共享同一个变量
        self.keyword_mode = tk.StringVar(value="include")  # 默认包含
        
        # 包含关键词行
        include_frame = ttk.Frame(include_exclude_frame)
        include_frame.pack(fill="x", padx=15,pady=2)
        
        self.include_radiobutton = ttk.Radiobutton(include_frame, text="包含关键词：", 
                            variable=self.keyword_mode, value="include",style="Radio.TRadiobutton")
        self.include_radiobutton.pack(side="left", padx=(0, 5))
        
        self.include_text_frame = ttk.Frame(include_frame)
        self.include_text_frame.pack(side="left", fill="x", expand=True)

        # 创建多行文本框
        self.include_text = tk.Text(
            self.include_text_frame,
            height=3,
            width=40,
            wrap="word",
            font=("Microsoft YaHei", 10)
        )
        self.include_text.pack(side="left", fill="both", expand=True)

        # 添加纵向滚动条
        self.include_scrollbar = ttk.Scrollbar(
            self.include_text_frame,
            orient="vertical",
            command=self.include_text.yview
        )
        self.include_scrollbar.pack(side="right", fill="y")

        # 设置滚动条联动
        self.include_text.config(yscrollcommand=self.include_scrollbar.set)
        
        ttk.Label(include_frame, text="（输入关键词）",
                 foreground="#7f8c8d", font=("Microsoft YaHei", 9)).pack(side="left", padx=5)

        # 排除关键词行
        exclude_frame = ttk.Frame(include_exclude_frame)
        exclude_frame.pack(fill="x", padx=15,pady=2)
        
        self.exclude_radiobutton = ttk.Radiobutton(exclude_frame, text="排除关键词：",
                                variable=self.keyword_mode, value="exclude",style="Radio.TRadiobutton")
        self.exclude_radiobutton.pack(side="left", padx=(0, 5))
        
        self.exclude_text_frame = ttk.Frame(exclude_frame)
        self.exclude_text_frame.pack(side="left", fill="x", expand=True)

        # 创建多行文本框
        self.exclude_text = tk.Text(
            self.exclude_text_frame,
            height=3,
            width=40,
            wrap="word",
            font=("Microsoft YaHei", 10)
        )
        self.exclude_text.pack(side="left", fill="both", expand=True)

        # 添加纵向滚动条
        self.exclude_scrollbar = ttk.Scrollbar(
            self.exclude_text_frame,
            orient="vertical",
            command=self.exclude_text.yview
        )
        self.exclude_scrollbar.pack(side="right", fill="y")

        # 设置滚动条联动
        self.exclude_text.config(yscrollcommand=self.exclude_scrollbar.set)
        
        ttk.Label(exclude_frame, text="（输入关键词）",
                 foreground="#7f8c8d", font=("Microsoft YaHei", 9)).pack(side="left", padx=5)
        
        self.keyword_focus_var.trace_add("write", self.update_keyword_entries_state)
        self.keyword_mode.trace_add("write", self.update_keyword_entries_state)
        self.update_keyword_entries_state()# 初始化状态

        # 创建开始检查按钮区域
        create_summary_frame = ttk.Frame(self.summary_frame)
        create_summary_frame.pack(fill="both", expand=False, padx=5, pady=2)

        ttk.Checkbutton(create_summary_frame, text="完成后打开文件", variable=self.open_file_var,style="ToggleAll.TCheckbutton").pack(side="left", padx=(5, 5))  # 右侧留白                    
        
        # 创建生成摘要按钮
        ttk.Button(create_summary_frame, text="生成摘要", 
                  style="Primary.TButton", command=self.generate_summary).pack(
            side="right", padx=10, pady=10)
        
    def select_file_path(self):
        file_path = filedialog.asksaveasfilename( 
            title="命名新文件",
            defaultextension=".docx",
            filetypes=[("doc Files", "*.docx")],
        )
        if file_path:
            self.file_path_label.config(text=file_path)
            self.new_summary_file_path = file_path
        else:
            self.file_path_label.config(text="")
            self.new_summary_file_path = ""
        return file_path
    
    
    def select_optimize_output_file_path(self):
        file_path = filedialog.asksaveasfilename( 
            title="输出文件路径",
            defaultextension=".docx",
            filetypes=[("doc Files", "*.docx")],
        )
        if file_path:
            self.file_path_label_optimize.config(text=file_path)
            self.optimize_output_file_path = file_path
        else:
            self.file_path_label_optimize.config(text="")
            self.optimize_output_file_path = ""
        return file_path
    def on_combobox_change(self, selected_value):
        if selected_value == "新建独立文档":
            self.file_path_button.pack(side="left", padx=5)
            self.file_path_label.pack(side="left", padx=5)
        else:
            self.file_path_button.pack_forget()
            self.file_path_label.pack_forget()
    
    def toggle_compare_file_visibility(self):
        """根据双文件比较开关状态切换文件选择控件的可见性"""
        if self.compare_files_var.get():            
            # 显示比较文件控件
            self.compare_option_frame.pack(fill="x", padx=20, pady=0,before=self.compare_file_frame)            
            self.compare_file_frame.pack(fill="x", padx=20, pady=(3,3))            
            self.compare_file_frame2.pack(fill="x", padx=20, pady=(3,3))
            self.label_check_file.config(text="基准文件")
            self.file_path_compare1_var.set("")
            self.file_path_compare2_var.set("")
        else:
            # 隐藏比较文件控件
            self.label_check_file.config(text="选择Word文档")
            self.compare_file_frame.pack(fill="x", padx=20, pady=(3,3))
            self.compare_option_frame.pack_forget()
            self.compare_file_frame2.pack_forget()
            self.file_path_compare1_var.set("")
            self.file_path_compare2_var.set("")
    
    def on_control_method_change(self, event=None):
        method = self.control_method_combo.get()
        if method == "按字数":
            self.label_len_desp.config(text="字符以内")
        elif method == "按比例":
            self.label_len_desp.config(text="%以内")
        elif method == "按句数":
            self.label_len_desp.config(text="句以内")
    def update_length_controls_state(self, *args):
        """根据长度控制复选框状态更新子控件可用性"""
        if self.len_control.get():
            # 启用下拉选择，但禁止手动输入
            self.control_method_combo.config(state="readonly")
        else:
            # 禁用控件
            self.control_method_combo.config(state="disabled")
        self.length_entry.config(state='normal' if self.len_control.get() else 'disabled')
        
    def create_radio_with_label(self,parent, text, value, tooltip):
        frame = ttk.Frame(parent)
        
        radio = ttk.Radiobutton(frame, text=text,
                            variable=self.summary_type, value=value,style="Radio.TRadiobutton")
        radio.pack(side="left", padx=(0, 5))  # 右侧留白
        
        label = ttk.Label(frame, text=tooltip, font=("Microsoft YaHei", 10), foreground="#7f8c8d",style="Label.TLabel")
        label.pack(side="left")
        return frame

    def create_checkbutton_with_label(self,parent, text, value, tooltip):
        frame = ttk.Frame(parent)
        checkbutton = ttk.Checkbutton(frame, text=text, variable=value,style="ToggleAll.TCheckbutton")   
        checkbutton.pack(side="left", padx=(0, 5))  # 单独调用 pack()                 
        label = ttk.Label(frame, text=tooltip, font=("Microsoft YaHei", 10), foreground="#7f8c8d",style="Label.TLabel")
        label.pack(side="left")
        return frame

    def update_keyword_entries_state(self, *args):
        """根据关键词聚焦状态和单选按钮状态更新输入框可用性"""
        focus_enabled = self.keyword_focus_var.get()
        mode = self.keyword_mode.get()

        # 设置输入框初始状态为禁用
        include_state = "normal" if focus_enabled and mode == "include" else "disabled"
        exclude_state = "normal" if focus_enabled and mode == "exclude" else "disabled"

        # 设置单选按钮状态
        radio_state = "normal" if focus_enabled else "disabled"

        # 更新控件状态
        self.include_text.config(state=include_state)
        self.exclude_text.config(state=exclude_state)
        self.include_radiobutton.config(state=radio_state)
        self.exclude_radiobutton.config(state=radio_state)

    def generate_summary(self):
        # 校验长度控制参数
        if self.len_control.get():
            control_method = self.control_method_combo.get()
            length_value_str = self.length_entry.get()
            
            # 按比例校验
            if control_method == "按比例":
                try:
                    length_value = float(length_value_str)
                    if not (10 <= length_value <= 100):
                        tk.messagebox.showwarning("警告", "按比例控制时，长度值必须在10%-100%之间")
                        self.length_entry.focus_set()  # 设置焦点到输入框
                        self.length_entry.selection_range(0, tk.END)  # 自动选中输入框全部内容
                        return
                except ValueError:
                    tk.messagebox.showwarning("警告", "按比例控制时，请输入有效的数字")
                    self.length_entry.focus_set()  # 设置焦点到输入框
                    self.length_entry.selection_range(0, tk.END)  # 自动选中输入框全部内容
                    return
                    
            # 按字数/句数校验
            elif control_method in ["按字数", "按句数"]:
                try:
                    length_value = int(length_value_str)
                    if length_value <= 0:
                        raise ValueError
                except ValueError:
                    tk.messagebox.showwarning("警告", "按字数/句数控制时，请输入有效的正整数")
                    self.length_entry.focus_set()  # 设置焦点到输入框
                    self.length_entry.selection_range(0, tk.END)  # 自动选中输入框全部内容
                    return
                
        """生成文档摘要"""
        location_map = {
            "插入原文档顶端": "插入原文档顶端",
            "插入原文档末尾": "插入原文档末尾",
            "新建独立文档": "新建独立文档"
        }
        
        method_map = {
            "按字数": "按字数",
            "按比例": "按比例",
            "按句数": "按句数"
        }
        
        config = {
            'summary_type': self.summary_type.get(),
            'summary_location': location_map.get(self.summary_location_combo.get(), '插入原文档顶端'),
            'new_summary_file_path':self.new_summary_file_path,
            'len_control': self.len_control.get(),            
            'control_method': method_map.get(self.control_method_combo.get(), '按字数'),
            'length_value': self.length_entry.get(),
            'keyword_focus': self.keyword_focus_var.get(),
            'keyword_mode': self.keyword_mode.get(),
            'keywords': self.include_text.get("1.0", tk.END) if self.keyword_mode.get() == 'include' else self.exclude_text.get("1.0", tk.END)
        }
        
        prompt_gen = PromptGenerator()
        return prompt_gen.generate_prompt('summary', config)
        
    def on_child_check(self, sub_vars, parent_var, parent_checkbox, *args):
        """
        子复选框状态变化时更新父级复选框状态
        :param sub_vars: 子复选框变量列表
        :param parent_var: 父级复选框变量
        :param parent_checkbox: 父级复选框控件
        """
        self.update_parent_checkbox(parent_var, sub_vars, parent_checkbox)

    def update_parent_checkbox(self, parent_var, sub_vars, parent_checkbox=None):
        """
        更新父级复选框状态（全选/半选）
        :param parent_var: 父级复选框变量
        :param sub_vars: 子复选框变量列表
        :param parent_checkbox: 父级复选框控件（可选）
        """
        checked_count = sum(1 for v in sub_vars if v.get())
        total_count = len(sub_vars)
        
        if checked_count == 0:
            parent_var.set(False)
            if parent_checkbox:
                parent_checkbox.state(['!alternate'])  # 移除半选状态
        elif checked_count == total_count:
            parent_var.set(True)
            if parent_checkbox:
                parent_checkbox.state(['!alternate'])  # 移除半选状态
        else:
            parent_var.set(False)  # 半选时不设置具体值
            if parent_checkbox:
                parent_checkbox.state(['alternate'])  # 设置半选状态 

if __name__ == "__main__":
    root = tk.Tk()
    app = WordAIAssistant(root)
    
    # 设置窗口尺寸
    root.geometry("1000x800")
    
    # 计算居中位置并确保不被任务栏遮挡
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    window_width = 1000
    window_height = 800
    
    # 计算位置 (减去50像素确保不被任务栏遮挡)
    x = (screen_width - window_width) // 2
    y = max(0, (screen_height - window_height - 50) // 2)  # 确保y不小于0
    
    # 设置窗口位置
    root.geometry(f"{window_width}x{window_height}+{x}+{y}")

    # 获取当前脚本文件的绝对路径
    script_dir = os.path.dirname(os.path.abspath(__file__))
    """ 获取打包后的资源绝对路径 """
    if getattr(sys, 'frozen', False):  # 判断是否被打包
        base_path = sys._MEIPASS
    else:
        base_path = os.path.join(script_dir, '..')
    icon_path = os.path.join(base_path, 'resources', 'officeAI.ico')  # 图标资源文件路径
    if os.path.exists(icon_path):
        root.iconbitmap(icon_path)
    
    root.mainloop()